package cn.mujiankeji.mbrowser.界面.小窗页.管理

import androidx.compose.foundation.background
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Add
import androidx.compose.material.icons.filled.Delete
import androidx.compose.material.icons.filled.Edit
import androidx.compose.material.icons.filled.Refresh
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.ExtendedFloatingActionButton
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Switch
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.scale
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.dp
import cn.mujiankeji.mbrowser.工具.mlog
import cn.mujiankeji.mbrowser.数据.数据库.DBUserScript
import cn.mujiankeji.mbrowser.数据.数据库.DaoUserScript
import cn.mujiankeji.mbrowser.工具.操作.用户脚本操作
import cn.mujiankeji.mbrowser.数据.数据库.AppDatabase
import cn.mujiankeji.mbrowser.界面.框架.小窗视图.小窗状态
import cn.mujiankeji.mbrowser.界面.组件.布局.底部窗口布局
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import org.koin.compose.koinInject

/**
 * 用户脚本窗口状态
 * 
 * 管理已安装的用户脚本，提供启用/禁用、删除、检查更新等功能
 */
class 用户脚本窗口状态 : 小窗状态() {
    // 当前正在检查更新的脚本ID
    var 正在检查更新脚本ID by mutableStateOf<Long?>(null)
    
    // 正在删除的脚本ID
    var 正在删除脚本ID by mutableStateOf<Long?>(null)
    
    // 脚本详情展开状态
    val 展开状态 = mutableMapOf<Long, Boolean>()

    var coroutine : CoroutineScope?=null
    
    /**
     * 切换脚本启用状态
     * 
     * @param 脚本 要切换状态的脚本
     * @param dao 数据库访问对象
     * @param 新状态 新的启用状态
     */
    fun 切换脚本启用状态(脚本: DBUserScript, dao: DaoUserScript, 新状态: Boolean) {
        脚本.启用 = 新状态
        kotlinx.coroutines.MainScope().launch {
            withContext(Dispatchers.IO) {
                dao.更新用户脚本(脚本)
            }
        }
    }
    
    /**
     * 删除脚本
     * 
     * @param 脚本 要删除的脚本
     * @param dao 数据库访问对象
     */
    fun 删除脚本(脚本: DBUserScript, dao: DaoUserScript) {
        正在删除脚本ID = 脚本.id
        kotlinx.coroutines.MainScope().launch {
            val 结果 = 用户脚本操作.删除脚本(脚本, dao)
            if (结果) {
                mlog("脚本 ${脚本.名称} 删除成功")
            } else {
                mlog("脚本 ${脚本.名称} 删除失败")
            }
            正在删除脚本ID = null
        }
    }
    
    /**
     * 检查脚本更新
     * 
     * @param 脚本 要检查更新的脚本
     */
    fun 检查脚本更新(脚本: DBUserScript, dao: DaoUserScript) {
        if (脚本.更新地址.isEmpty()) {
            mlog("脚本 ${脚本.名称} 没有更新地址")
            return
        }
        
        正在检查更新脚本ID = 脚本.id
        kotlinx.coroutines.MainScope().launch {
            try {
                val 有更新 = 用户脚本操作.检查更新(脚本.更新地址, 脚本.版本)
                if (有更新) {
                    mlog("脚本 ${脚本.名称} 有新版本可用")
                    // 获取新版本内容
                    val 新版本内容 = withContext(Dispatchers.IO) {
                        cn.mujiankeji.mbrowser.工具.网络.网络操作.获取文本(脚本.更新地址)
                    }
                    
                    if (新版本内容 != null) {
                        // 显示更新确认窗口
                        用户脚本操作.请求安装脚本(新版本内容, dao) { 成功, _ ->
                            if (成功) {
                                mlog("脚本 ${脚本.名称} 更新成功")
                            } else {
                                mlog("脚本 ${脚本.名称} 更新取消或失败")
                            }
                        }
                    }
                } else {
                    mlog("脚本 ${脚本.名称} 已是最新版本")
                }
            } catch (e: Exception) {
                mlog("检查脚本 ${脚本.名称} 更新失败: ${e.message}")
            } finally {
                正在检查更新脚本ID = null
            }
        }
    }
    
    /**
     * 切换脚本详情展开状态
     */
    fun 切换展开状态(脚本ID: Long) {
        展开状态[脚本ID] = !(展开状态[脚本ID] ?: false)
    }
    
    /**
     * 获取脚本展开状态
     */
    fun 获取展开状态(脚本ID: Long): Boolean {
        return 展开状态[脚本ID] ?: false
    }
    
    /**
     * 创建新脚本
     * 打开脚本编辑标签页
     */
    fun 创建新脚本() {
        coroutine?.launch {
            // 打开脚本编辑标签页
            val 脚本编辑状态 = cn.mujiankeji.mbrowser.界面.标签页.脚本.脚本编辑标签状态()
            cn.mujiankeji.mbrowser.app.应用接口.界面模块().加载(脚本编辑状态)

            // 关闭当前窗口
            销毁小窗()
        }
    }
    
    /**
     * 编辑脚本
     * 打开脚本编辑标签页并加载现有脚本
     */
    fun 编辑脚本(脚本: DBUserScript) {
        coroutine?.launch {
            // 打开脚本编辑标签页
            val 脚本编辑状态 = cn.mujiankeji.mbrowser.界面.标签页.脚本.脚本编辑标签状态(脚本.id)
            cn.mujiankeji.mbrowser.app.应用接口.界面模块().加载(脚本编辑状态)
            
            // 关闭当前窗口
            销毁小窗()
        }
    }
}

/**
 * 用户脚本窗口实现
 * 
 * @param state 窗口状态
 */
@Composable
fun 用户脚本窗口实现(state: 用户脚本窗口状态) {
    val dao = koinInject<AppDatabase>().用户脚本()
    val 脚本列表Flow = remember { dao.获取所有用户脚本() }
    val 脚本列表 by 脚本列表Flow.collectAsState(initial = emptyList())
    state.coroutine = rememberCoroutineScope()


    底部窗口布局(销毁  = { state.销毁小窗() }) {
        Box(modifier = Modifier.fillMaxSize()) {
            if (脚本列表.isEmpty()) {
                // 空列表提示
                Box(
                    modifier = Modifier.fillMaxSize(),
                    contentAlignment = Alignment.Center
                ) {
                    Text(
                        text = "暂无已安装的用户脚本",
                        style = MaterialTheme.typography.bodyLarge,
                        color = MaterialTheme.colorScheme.onSurfaceVariant
                    )
                }
            } else {
                // 脚本列表
                LazyColumn(
                    modifier = Modifier.fillMaxSize()
                ) {
                    items(脚本列表) { 脚本 ->
                        脚本项目(state, 脚本, dao)
                    }
                }
            }
            
            // 添加新脚本按钮
            ExtendedFloatingActionButton(
                onClick = { state.创建新脚本() },
                icon = { Icon(Icons.Filled.Add, contentDescription = "添加") },
                text = { Text("新建脚本") },
                modifier = Modifier
                    .align(Alignment.BottomEnd)
                    .padding(16.dp)
            )
        }
    }
}

/**
 * 脚本项目
 * 
 * @param state 窗口状态
 * @param 脚本 脚本数据
 * @param dao 数据库访问对象
 */
@Composable
private fun 脚本项目(state: 用户脚本窗口状态, 脚本: DBUserScript, dao: DaoUserScript) {
    val 展开 = remember(脚本.id) { mutableStateOf(state.获取展开状态(脚本.id)) }
    val scope = rememberCoroutineScope()
    
    Column(
        Modifier
            .fillMaxWidth()
            .padding(horizontal = 12.dp, vertical = 8.dp)
            .clickable { 
                展开.value = !展开.value
                state.切换展开状态(脚本.id)
            }
    ) {
        // 基本信息行
        Row(
            Modifier.fillMaxWidth(),
            verticalAlignment = Alignment.CenterVertically
        ) {
            // 脚本名称和基本信息
            Column(
                Modifier.weight(1f)
            ) {
                Text(
                    text = 脚本.名称,
                    maxLines = if (展开.value) Int.MAX_VALUE else 1,
                    overflow = TextOverflow.Ellipsis,
                    style = MaterialTheme.typography.titleMedium,
                    color = MaterialTheme.colorScheme.onSurface
                )
                
                Spacer(modifier = Modifier.height(2.dp))
                
                // 版本和作者信息
                Row(verticalAlignment = Alignment.CenterVertically) {
                    if (脚本.版本.isNotEmpty()) {
                        Text(
                            text = "v${脚本.版本}",
                            style = MaterialTheme.typography.bodySmall,
                            color = MaterialTheme.colorScheme.onSurfaceVariant
                        )
                    }
                    
                    if (脚本.版本.isNotEmpty() && 脚本.作者.isNotEmpty()) {
                        Text(
                            text = " • ",
                            style = MaterialTheme.typography.bodySmall,
                            color = MaterialTheme.colorScheme.onSurfaceVariant
                        )
                    }
                    
                    if (脚本.作者.isNotEmpty()) {
                        Text(
                            text = 脚本.作者,
                            style = MaterialTheme.typography.bodySmall,
                            color = MaterialTheme.colorScheme.onSurfaceVariant
                        )
                    }
                }
            }
            
            // 操作按钮
            Row(verticalAlignment = Alignment.CenterVertically) {
                // 编辑按钮
                IconButton(
                    onClick = { state.编辑脚本(脚本) }
                ) {
                    Icon(
                        imageVector = Icons.Default.Edit,
                        contentDescription = "编辑脚本",
                        tint = MaterialTheme.colorScheme.primary
                    )
                }
                
                // 检查更新按钮
                if (脚本.更新地址.isNotEmpty()) {
                    Box(contentAlignment = Alignment.Center) {
                        IconButton(
                            onClick = { state.检查脚本更新(脚本, dao) },
                            enabled = state.正在检查更新脚本ID != 脚本.id && state.正在删除脚本ID != 脚本.id
                        ) {
                            Icon(
                                imageVector = Icons.Default.Refresh,
                                contentDescription = "检查更新",
                                tint = MaterialTheme.colorScheme.primary
                            )
                        }
                        
                        if (state.正在检查更新脚本ID == 脚本.id) {
                            CircularProgressIndicator(
                                modifier = Modifier.size(24.dp),
                                strokeWidth = 2.dp
                            )
                        }
                    }
                }
                
                // 删除按钮
                Box(contentAlignment = Alignment.Center) {
                    IconButton(
                        onClick = { state.删除脚本(脚本, dao) },
                        enabled = state.正在删除脚本ID != 脚本.id && state.正在检查更新脚本ID != 脚本.id
                    ) {
                        Icon(
                            imageVector = Icons.Default.Delete,
                            contentDescription = "删除脚本",
                            tint = MaterialTheme.colorScheme.error
                        )
                    }
                    
                    if (state.正在删除脚本ID == 脚本.id) {
                        CircularProgressIndicator(
                            modifier = Modifier.size(24.dp),
                            strokeWidth = 2.dp
                        )
                    }
                }
                
                // 启用/禁用开关
                Switch(
                    checked = 脚本.启用,
                    onCheckedChange = { 
                        state.切换脚本启用状态(脚本, dao, it)
                    },
                    modifier = Modifier.scale(0.8f)
                )
            }
        }
        
        // 展开的详细信息
        if (展开.value) {
            Spacer(modifier = Modifier.height(8.dp))
            
            // 描述
            if (脚本.描述.isNotEmpty()) {
                Text(
                    text = 脚本.描述,
                    style = MaterialTheme.typography.bodyMedium,
                    color = MaterialTheme.colorScheme.onSurfaceVariant,
                    modifier = Modifier.padding(start = 8.dp)
                )
                
                Spacer(modifier = Modifier.height(8.dp))
            }
            
            // 匹配地址
            if (脚本.匹配地址.isNotEmpty()) {
                Text(
                    text = "匹配地址:",
                    style = MaterialTheme.typography.bodyMedium,
                    fontWeight = FontWeight.Medium,
                    modifier = Modifier.padding(start = 8.dp)
                )
                
                脚本.匹配地址.take(3).forEach { url ->
                    Text(
                        text = "• $url",
                        style = MaterialTheme.typography.bodySmall,
                        color = MaterialTheme.colorScheme.onSurfaceVariant,
                        modifier = Modifier.padding(start = 16.dp)
                    )
                }
                
                if (脚本.匹配地址.size > 3) {
                    Text(
                        text = "• ... 等${脚本.匹配地址.size}个地址",
                        style = MaterialTheme.typography.bodySmall,
                        color = MaterialTheme.colorScheme.onSurfaceVariant,
                        modifier = Modifier.padding(start = 16.dp)
                    )
                }
                
                Spacer(modifier = Modifier.height(8.dp))
            }
            
            // 运行时机
            Row(
                modifier = Modifier.padding(start = 8.dp),
                verticalAlignment = Alignment.CenterVertically
            ) {
                Text(
                    text = "运行时机: ",
                    style = MaterialTheme.typography.bodySmall,
                    fontWeight = FontWeight.Medium
                )
                
                脚本.运行时机.forEach { timing ->
                    Box(
                        modifier = Modifier
                            .padding(end = 4.dp)
                            .background(
                                MaterialTheme.colorScheme.secondaryContainer,
                                CircleShape
                            )
                            .padding(horizontal = 6.dp, vertical = 2.dp)
                    ) {
                        Text(
                            text = timing,
                            style = MaterialTheme.typography.bodySmall,
                            color = MaterialTheme.colorScheme.onSecondaryContainer
                        )
                    }
                }
            }
            
            Spacer(modifier = Modifier.height(8.dp))
            
            // 权限信息
            if (脚本.油猴API.isNotEmpty()) {
                Row(
                    modifier = Modifier.padding(start = 8.dp),
                    verticalAlignment = Alignment.CenterVertically
                ) {
                    Text(
                        text = "请求权限: ",
                        style = MaterialTheme.typography.bodySmall,
                        fontWeight = FontWeight.Medium
                    )
                    
                    Text(
                        text = "${脚本.油猴API.size}个API",
                        style = MaterialTheme.typography.bodySmall,
                        color = MaterialTheme.colorScheme.onSurfaceVariant
                    )
                }
            }
        }
        
        Spacer(modifier = Modifier.height(8.dp))
    }
}